﻿#include "tap_api_trader.h"
#include <filesystem>
#include <time_utils.hpp>
#include "../../api/TAP_V9_20200808/TapAPIError.h"

// tap_api_trader 构造函数
// 功能：初始化交易 API 对象并加载相关配置
// 参数：
// - id_excg_map: 交易所 ID 映射
// - config: 交易参数配置
tap_api_trader::tap_api_trader(const std::shared_ptr<std::unordered_map<std::string, std::string>>& id_excg_map, const params& config) noexcept
    : asyn_actual_trader(id_excg_map)
    , _td_api(nullptr)
    , _reqid(0)
    , _order_ref(0)
    , _login_time(0)
    , _is_runing(false)
    , _process_mutex(_mutex)
    , _is_inited(false)
    , _is_connected(false)
    , _is_sync_wait(false)
    , _is_in_query(false)
{
    // 从配置中读取必要的参数
    try
    {
        _ip = config.get<std::string>("ip");
        _port = config.get<uint16_t>("port");
        _userid = config.get<std::string>("userid");
        _password = config.get<std::string>("passwd");
        _authcode = config.get<std::string>("authcode");
        _appid = config.get<std::string>("appid");
    }
    catch (...)
    {
        // 记录错误日志，初始化失败
        LOG_ERROR("tap trader init error ");
    }

    // 加载 TapTradeAPI 动态库
    _trader_handle = dll_helper::load_library("TapTradeAPI");
    if (_trader_handle)
    {
        // 获取 API 创建和销毁函数的指针
        _tap_creator = (trader_creator)dll_helper::get_symbol(_trader_handle, "CreateTapTradeAPI");
        _tap_destroyer = (trader_destroyer)dll_helper::get_symbol(_trader_handle, "FreeTapTradeAPI");
    }
    else
    {
        // 加载失败记录错误日志
        LOG_ERROR("tap trader TapQuoteAPI load error ");
    }

    LOG_INFO("tap market init");
}

// tap_api_trader 析构函数
// 功能：释放交易 API 资源
tap_api_trader::~tap_api_trader() noexcept
{
    dll_helper::free_library(_trader_handle);
    _trader_handle = nullptr;
}

// 登录函数
// 功能：登录交易系统
// 返回值：登录成功返回 true，否则返回 false
bool tap_api_trader::login() noexcept
{
    _is_runing = true;

    // 创建 API 实例
    TAPIINT32 iResult = TAPIERROR_SUCCEED;
    TapAPIApplicationInfo stAppInfo;
    strcpy(stAppInfo.AuthCode, _authcode.c_str());
    const char* log_path = "./log/api";
    if (!std::filesystem::exists(log_path))
    {
        std::filesystem::create_directories(log_path);
    }
    strcpy(stAppInfo.KeyOperationLogPath, log_path);

    // 调用创建 API 实例的函数
    _td_api = _tap_creator(&stAppInfo, iResult);
    if (NULL == _td_api)
    {
        LOG_FATAL("创建API实例失败，错误码：", iResult);
        return false;
    }

    // 设置 API 异步消息接收器
    _td_api->SetAPINotify(this);

    // 设置服务器 IP 和端口
    TAPIINT32 iErr = _td_api->SetHostAddress(_ip.c_str(), _port);
    if (TAPIERROR_SUCCEED != iErr)
    {
        LOG_ERROR("SetHostAddress Error:", iErr);
        return false;
    }

    // 登录服务器
    TapAPITradeLoginAuth stLoginAuth;
    memset(&stLoginAuth, 0, sizeof(stLoginAuth));
    strcpy(stLoginAuth.UserNo, _userid.c_str());
    strcpy(stLoginAuth.Password, _password.c_str());
    strcpy(stLoginAuth.AuthCode, _authcode.c_str());
    strcpy(stLoginAuth.AppID, _appid.c_str());
    stLoginAuth.ISModifyPassword = APIYNFLAG_NO;
    stLoginAuth.ISDDA = APIYNFLAG_NO;
    stLoginAuth.NoticeIgnoreFlag = TAPI_NOTICE_IGNORE_FUND | TAPI_NOTICE_IGNORE_FILL | TAPI_NOTICE_IGNORE_POSITION | TAPI_NOTICE_IGNORE_CLOSE | TAPI_NOTICE_IGNORE_POSITIONPROFIT;

    // 发送登录请求
    iErr = _td_api->Login(&stLoginAuth);
    if (TAPIERROR_SUCCEED != iErr)
    {
        LOG_ERROR("Login Error:", iErr);
        return false;
    }

    LOG_INFO("ctp_api_trader init ");
    // 等待登录响应
    _process_signal.wait(_process_mutex);

    _is_inited = true;
    return true;
}

// 登出函数
// 功能：登出交易系统并清理资源
void tap_api_trader::logout() noexcept
{
    _is_runing = false;

    _reqid = 0;
    _order_ref = 0;
    _login_time = 0;  // 登录本地时间戳

    // 清空持仓和订单信息
    _position_info.clear();
    _order_info.clear();

    _is_inited = false;
    _is_connected = false;
    _is_sync_wait.exchange(false);

    // 销毁 API 实例
    if (_td_api)
    {
        _tap_destroyer(_td_api);
        _td_api = nullptr;
    }
}

// 查询持仓
// 功能：查询当前持仓信息
// 参数：is_sync - 是否同步查询
// 返回值：查询成功返回 true，否则返回 false
bool tap_api_trader::query_positions(bool is_sync) noexcept
{
    if (_td_api == nullptr)
    {
        LOG_ERROR("tap trader api nullptr");
        return false;
    }
    if (_is_in_query)
    {
        LOG_ERROR("tap trader query_positions _is_in_query true");
        return false;
    }
    LOG_INFO("tap trader query_positions :", is_sync);
    TapAPIPositionQryReq qryReq;
    auto err = _td_api->QryPosition(&_reqid, &qryReq);
    if (err != TAPIERROR_SUCCEED)
    {
        LOG_ERROR("tap trader QryPosition Error:", err);
        return false;
    }
    while (_is_in_query.exchange(true));
    if (is_sync)
    {
        while (!_is_sync_wait.exchange(true));
        _process_signal.wait(_process_mutex);
    }
    return true;
}

// 查询订单
// 功能：查询当前未结束的订单信息
// 参数：is_sync - 是否同步查询
// 返回值：查询成功返回 true，否则返回 false
bool tap_api_trader::query_orders(bool is_sync) noexcept
{
    if (_td_api == nullptr)
    {
        LOG_ERROR("tap trader api nullptr");
        return false;
    }
    if (_is_in_query)
    {
        LOG_ERROR("tap trader query_orders _is_in_query true");
        return false;
    }
    LOG_INFO("tap trader query_orders :", is_sync);
    TapAPIOrderQryReq qryReq;
    qryReq.OrderQryType = TAPI_ORDER_QRY_TYPE_UNENDED;
    auto err = _td_api->QryOrder(&_reqid, &qryReq);
    if (err != TAPIERROR_SUCCEED)
    {
        LOG_ERROR("tap trader QryOrder Error:", err);
        return false;
    }
    while (_is_in_query.exchange(true));
    if (is_sync)
    {
        while (!_is_sync_wait.exchange(true));
        _process_signal.wait(_process_mutex);
    }
    return true;
}

// 连接成功回调
void tap_api_trader::OnConnect() noexcept
{
    _is_connected = true;
}

// 登录响应回调
void tap_api_trader::OnRspLogin(TAPIINT32 errorCode, const TapAPITradeLoginRspInfo* loginRspInfo) noexcept
{
    if (TAPIERROR_SUCCEED == errorCode)
    {
        LOG_INFO("登录成功，等待API初始化...");
        if (loginRspInfo)
        {
            _trading_day = date_to_uint(loginRspInfo->TradeDate);
            auto now = std::chrono::system_clock::now().time_since_epoch();
            _login_time = static_cast<uint32_t>(std::chrono::duration_cast<std::chrono::seconds>(now).count());
        }
    }
    else
    {
        LOG_ERROR("登录失败，错误码:", errorCode);
    }
}

// API 就绪回调
void tap_api_trader::OnAPIReady() noexcept
{
    LOG_INFO("OnAPIReady :", _ip.c_str(), _port);
    _process_signal.notify_all();
}

// 断开连接回调
void tap_api_trader::OnDisconnect(TAPIINT32 reasonCode) noexcept
{
    _is_connected = false;
}

// 订单响应回调
void tap_api_trader::OnRtnOrder(const TapAPIOrderInfoNotice* notice) noexcept
{
    // 处理订单状态变化的逻辑
}

// 订单操作响应回调
void tap_api_trader::OnRspOrderAction(TAPIUINT32 sessionID, TAPIUINT32 errorCode, const TapAPIOrderActionRsp* info) noexcept
{
    // 处理订单操作响应
}

// 查询订单响应回调
void tap_api_trader::OnRspQryOrder(TAPIUINT32 sessionID, TAPIINT32 errorCode, TAPIYNFLAG isLast, const TapAPIOrderInfo* info) noexcept
{
    // 处理订单查询响应
}

// 查询持仓响应回调
void tap_api_trader::OnRspQryPosition(TAPIUINT32 sessionID, TAPIINT32 errorCode, TAPIYNFLAG isLast, const TapAPIPositionInfo* info) noexcept
{
    // 处理持仓查询响应
}

// 检查是否可用
bool tap_api_trader::is_usable() const noexcept
{
    if (_td_api == nullptr)
    {
        return false;
    }
    if (!_is_inited)
    {
        return false;
    }
    return _is_connected;
}

// 下单函数
// 功能：发送下单请求
// 返回值：返回订单 ID，如果失败返回 INVALID_ESTID
estid_t tap_api_trader::place_order(offset_type offset, direction_type direction, const code_t& code, uint32_t volume, double_t price, order_flag flag) noexcept
{
    // 构建订单请求并发送
}

// 撤单函数
// 功能：发送撤单请求
// 返回值：成功返回 true，失败返回 false
bool tap_api_trader::cancel_order(estid_t estid) noexcept
{
    // 构建撤单请求并发送
}

// 获取当前交易日
uint32_t tap_api_trader::get_trading_day() const noexcept
{
    if (_td_api)
    {
        return _trading_day;
    }
    return 0X0U;
}

// 获取交易数据
std::shared_ptr<trader_data> tap_api_trader::get_trader_data() noexcept
{
    // 查询持仓和订单数据并返回
}
